package com.ideal.manage.esms.controller.project;

import com.ideal.manage.esms.bean.DTO.PageDto;
import com.ideal.manage.esms.bean.DTO.Result;
import com.ideal.manage.esms.bean.project.*;
import com.ideal.manage.esms.service.project.*;
import com.ideal.manage.esms.service.system.UserProjectService;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.List;

/**
 *
 * @author 83730
 * @date 2018/4/17
 * Remark: 工程配置 -> 对象管理 Controller
 */
@Controller
@RequestMapping("project/objectManage")
public class ObjectManageController {
    private Logger logger = LoggerFactory.getLogger(ObjectManageController.class);

    @Resource
    private ProjectManageService projectManageService;
    @Resource
    private EquipmentManageService equipmentManageService;
    @Resource
    private EquipmentMessageConfService equipmentMessageConfService;
    @Resource
    private EquipmentTemperatureConfService equipmentTemperatureConfService;
    @Resource
    private ParameterInfoService parameterInfoService;
    @Resource
    private ArithmeticManageService arithmeticManageService;
    @Resource
    private UserProjectService userProjectService;


    /**
     * 对象管理外面的边框
     */
    @RequestMapping("object_list")
    public void objectList() {
    }

// ----------------------------------------------------------------------------------------------------------------------- 外框就不用管了 End

    /**
     * 工程配置 -> 对象管理 -> 项目管理
     */
    @RequestMapping("project_list")
    public void projectList() {
        logger.info("工程配置 -> 对象管理 -> 项目管理");
    }

    /**
     * 工程配置 -> 对象管理 -> 项目管理 -> 数据表
     *
     * @param request
     * @param pageNum
     * @return
     */
    @RequestMapping("project_data")
    @ResponseBody
    public PageDto projectData(int pageNum, HttpServletRequest request) {
        PageDto pageDto = projectManageService.findAll(pageNum, request);
        return pageDto;
    }

    /**
     * 工程配置 -> 对象管理 -> 项目管理 -> 新增/修改
     *
     * @param id
     * @param model
     */
    @RequestMapping("add_project")
    public void addProject(@RequestParam(required = false) String id, Model model) {
        if (StringUtils.isNotBlank(id)) {
            model.addAttribute("id", id);
            ProjectManage projectManage = projectManageService.findOne(id);
            model.addAttribute("projectManage", projectManage);
        }
    }

    /**
     * 工程配置 -> 对象管理 -> 项目管理 -> 保存
     *
     * @param id
     * @param name
     * @param ip
     * @param uploadCycle
     * @return
     */
    @RequestMapping("save_project")
    @ResponseBody
    public Result saveProject(@RequestParam(required = false) String id,
                              String name, String ip, Long uploadCycle) {
        String message = projectManageService.saveProject(id, name, ip, uploadCycle);
        Result result = new Result();
        result.setType("alert");
        result.setMessage(message);
        switch (message){
            case "保存成功":
                result.setStatus(0L);
                break;
            case "项目名不可重复":
                result.setStatus(1L);
                break;
        }
        return result;
    }

    /**
     * 工程配置 -> 对象管理 -> 项目管理 -> 删除
     *
     * @param ids
     * @return
     */
    @RequestMapping("delete_project")
    @ResponseBody
    public Result deleteProject(String[] ids) {
        if (ids.length < 1) {
            Result result = new Result();
            result.setType("alert");
            result.setMessage("未能正确获取项目id");
            return result;
        } else {
            // 1. 删除项目
            projectManageService.deleteProject(ids);
            // 2. 删除项目对应的设备
            equipmentManageService.deleteEquipmentByProject(ids);
            // 3. 删除用户与项目的关联
            userProjectService.delUserProjects(ids);
            Result result = new Result();
            result.setType("alert");
            result.setMessage("删除成功");
            return result;
        }
    }

    /**
     * Dai 2018-04-11
     * 工程配置 -> 对象管理 -> 项目管理 -> 编辑设备树
     *
     * @param model
     * @param id
     */
    @RequestMapping("project_edit")
    public void projectEdit(Model model, String id) {
        // 1. 设备树的id
        model.addAttribute("id", id);
        // 2. 获取树结构
        List ztreeDtos = projectManageService.findZtreeDtoById(id);
        ztreeDtos = equipmentManageService.findAllByProjectId(id, ztreeDtos);
        model.addAttribute("ztreeDtos", ztreeDtos);
    }

    /**
     * 工程配置 -> 对象管理 -> 项目管理 -> 编辑设备树 -> 导出树结构
     *
     * @param response
     * @param id
     */
    @RequestMapping("export_tree")
    public void exportTree(HttpServletResponse response, String id) {
        equipmentManageService.exportTree(response, id);
    }

    /**
     * 工程配置 -> 对象管理 -> 项目管理 -> 编辑设备树 -> 导入树结构
     *
     * @param file
     * @param id
     */
    @RequestMapping("import_tree")
    @ResponseBody
    public Object importTree(MultipartFile file, String id) {
        String message = equipmentManageService.importTree(file, id);
        return getResult(message, id);
    }


    /**
     * 工程配置 -> 对象管理 -> 项目管理 -> 编辑设备树 -> 保存重命名的子节点
     *
     * @param parent_id
     * @param project_id
     * @param name
     * @param type
     * @param id
     * @return
     */
    @RequestMapping("save_equipment_name")
    @ResponseBody
    public List saveEquipmentName(String parent_id, String project_id, String name, String type, String id) {
        // 1. 保存
        equipmentManageService.saveEquipmentName(parent_id, project_id, name, type, id);
        // 2. 重新获取树
        List ztreeDtos = projectManageService.findZtreeDtoById(project_id);
        ztreeDtos = equipmentManageService.findAllByProjectId(project_id, ztreeDtos);
        return ztreeDtos;
    }

    /**
     * 工程配置 -> 对象管理 -> 项目管理 -> 编辑设备树 -> 删除
     *
     * @param id
     * @param project_id
     * @return
     */
    @RequestMapping("delete_equipment")
    @ResponseBody
    public List deleteEquipment(String id, String project_id) {
        // 1. 删除项目部署的算法关系
        arithmeticManageService.delByEquipmentId(id);
        // 2. 删除
        equipmentManageService.deleteEquipment(id);
        // 3. 重新获取树
        List ztreeDtos = projectManageService.findZtreeDtoById(project_id);
        ztreeDtos = equipmentManageService.findAllByProjectId(project_id, ztreeDtos);
        return ztreeDtos;
    }

    /**
     * 工程配置 -> 对象管理 -> 项目管理 -> 编辑设备树 -> 批量添加变流器和电池包
     */
    @RequestMapping("project_add_list")
    public void projectAddList() {
    }

    /**
     * 工程配置 -> 对象管理 -> 项目管理 -> 编辑设备树 -> 批量添加电池组和电池单体
     *
     * @param model
     * @param id
     */
    @RequestMapping("project_add_group")
    public void projectAddGroup(Model model, String id) {
        EquipmentManage equipmentManage = equipmentManageService.findOne(id);
        model.addAttribute("package_id", id);
        model.addAttribute("name", equipmentManage.getName());
    }

    /**
     * 工程配置 -> 对象管理 -> 项目管理 -> 编辑设备树 -> 批量添加变流器和电池包 -> 保存
     *
     * @return
     */
    @RequestMapping("save_equipment_list")
    @ResponseBody
    public List saveEquipmentList(String project_id,
                                  String pcs_name, Long pcs_low, Long pcs_high,
                                  String bms_name, Long bms_low, Long bms_high) {
        // 1. 保存列表
        equipmentManageService.saveEquipmentList(project_id, pcs_name, pcs_low, pcs_high, bms_name, bms_low, bms_high);
        // 2. 重新获取树
        List ztreeDtos = projectManageService.findZtreeDtoById(project_id);
        ztreeDtos = equipmentManageService.findAllByProjectId(project_id, ztreeDtos);
        return ztreeDtos;
    }

    /**
     * 工程配置 -> 对象管理 -> 项目管理 -> 编辑设备树 -> 批量添加电池组和电池单体 -> 保存
     *
     * @param id
     * @param source
     * @return
     */
    @RequestMapping("save_equipment_group")
    @ResponseBody
    public Object saveEquipmentGroup(String id, String source, String project_id) {
        String message = equipmentManageService.saveEquipmentGroup(id, source);
        return getResult(message, project_id);
    }

    /**
     * 工程配置 -> 对象管理 -> 项目管理 -> 编辑设备树 -> 编辑
     *
     * @param id
     */
    @RequestMapping("project_edit_configure")
    public void projectEditConfigure(Model model, String id) {
        EquipmentManage equipmentManage = equipmentManageService.findOne(id);
        model.addAttribute("equipmentManage", equipmentManage);
    }

    /**
     * 工程配置 -> 对象管理 -> 项目管理 -> 编辑设备树 -> 保存编辑
     *
     * @param file
     * @param id
     * @param communication
     * @param project_id
     * @return
     */
    @RequestMapping("save_project_edit_configure")
    @ResponseBody
    public Object saveProjectEditConfigure(MultipartFile file,
                                           String id, String communication, String project_id) {
        String message = equipmentManageService.saveProjectEditConfigure(file, id, communication);
        return getResult(message, project_id);
    }

    /**
     * 工程配置 -> 对象管理 -> 项目管理 -> 编辑设备树 -> 批量编辑
     *
     * @param id
     */
    @RequestMapping("project_edit_list")
    public void projectEditList(String id, Model model) {
        ProjectManage projectManage = projectManageService.findOne(id);
        model.addAttribute("projectManage", projectManage);
        List list = equipmentManageService.findParentByProjectId(id);
        model.addAttribute("ztree_node_only_parent", list);
    }

    /**
     * 工程配置 -> 对象管理 -> 项目管理 -> 编辑设备树 -> 保存批量编辑
     *
     * @param project_id
     * @param ids
     * @param pcs_communication
     * @param bms_communication
     * @param pcs_file
     * @param bms_file
     * @return
     */
    @RequestMapping("save_project_edit_list")
    @ResponseBody
    public Object saveProjectEditList(String project_id, String ids,
                                      @RequestParam(required = false) String pcs_communication, @RequestParam(required = false) String bms_communication,
                                      @RequestParam(required = false) MultipartFile pcs_file, @RequestParam(required = false) MultipartFile bms_file) {
        String message = equipmentManageService.saveProjectEditList(project_id, ids, pcs_communication, bms_communication, pcs_file, bms_file);
        return getResult(message, project_id);
    }

    /**
     * 通用返回值
     *
     * @param message
     * @param project_id
     * @return
     */
    public Object getResult(String message, String project_id) {
        if (StringUtils.isNotBlank(message)) {
            Result result = new Result();
            result.setType("alert");
            result.setMessage(message);
            return result;
        } else {
            // 2. 重新获取树
            List ztreeDtos = projectManageService.findZtreeDtoById(project_id);
            ztreeDtos = equipmentManageService.findAllByProjectId(project_id, ztreeDtos);
            return ztreeDtos;
        }
    }
// ------------------------------------------------------------------------------------------------------------------------------ 项目管理 End

    /**
     * 工程配置 -> 对象管理 -> 设备管理
     */
    @RequestMapping("equipment_list")
    public void equipmentList() {
        logger.info("工程配置 -> 对象管理 -> 设备管理");
    }

    /**
     * 工程配置 -> 对象管理 -> 设备管理 -> 数据表
     *
     * @param pageNum
     * @param request
     * @return
     */
    @RequestMapping("equipment_data")
    @ResponseBody
    public PageDto equipmentData(int pageNum, HttpServletRequest request) {
        PageDto pageDto = equipmentManageService.findAll(pageNum, request);
        return pageDto;
    }

    /**
     * 工程配置 -> 对象管理 -> 设备管理 -> 查看报文数据列表
     *
     * @return
     */
    @RequestMapping("message_list")
    public void messageList(Model model, String id) {
        model.addAttribute("id", id);
        logger.info("工程配置 -> 对象管理 -> 设备管理 -> 查看报文数据列表");
    }

    /**
     * 工程配置 -> 对象管理 -> 设备管理 -> 查看报文数据列表
     *
     * @param pageNum
     * @param id
     * @param request
     * @return
     */
    @RequestMapping("message_data")
    @ResponseBody
    public PageDto messageData(int pageNum, String id, HttpServletRequest request) {
        PageDto pageDto = equipmentMessageConfService.findAll(pageNum, request, id);
        return pageDto;
    }

    /**
     * 工程配置 -> 对象管理 -> 设备管理 -> 查看报文数据列表 -> 新增/修改
     *
     * @param id
     * @return
     */
    @RequestMapping("message_edit")
    public void messageEdit(Model model, @RequestParam(required = false) String id, String equipment_id) {
        model.addAttribute("equipment_id", equipment_id);
        if (StringUtils.isNotBlank(id)) {
            EquipmentMessageConf equipmentMessageConf = equipmentMessageConfService.findOne(id);
            model.addAttribute("equipmentMessageConf", equipmentMessageConf);
        }
    }

    /**
     * 工程配置 -> 对象管理 -> 设备管理 -> 查看报文数据列表 -> 保存
     *
     * @return
     */
    @RequestMapping("save_message")
    @ResponseBody
    public Result saveMessage(@RequestParam(required = false) String id, String equipment_id, String subjectName, String canId, String canLong,
                              String head, String dataType, String beginByte, String beginPosition, String endByte,
                              String endPosition, String offset, String multiple, String unit, String objId) {
        logger.info("工程配置 -> 对象管理 -> 设备管理 -> 查看报文数据列表 -> 保存");
        String message = equipmentMessageConfService
                .saveMessage(id, equipment_id, subjectName, canId, canLong, head, dataType, beginByte,
                        beginPosition, endByte, endPosition, offset, multiple, unit, objId);
        Result result = new Result();
        result.setType("alert");
        result.setMessage(message);
        return result;
    }

    /**
     * 工程配置 -> 对象管理 -> 设备管理 -> 查看报文数据列表 -> 删除
     *
     * @param ids
     * @return
     */
    @RequestMapping("message_delete")
    @ResponseBody
    public Result messageDelete(String[] ids) {
        Result result = new Result();
        result.setType("alert");
        if (ids.length < 0) {
            result.setMessage("获取id失败");
        } else {
            equipmentMessageConfService.messageDelete(ids);
            result.setMessage("删除成功");
        }
        return result;
    }

    /**
     * 工程配置 -> 对象管理 -> 设备管理 -> 查看报文数据列表 -> 导出
     *
     * @param response
     * @param id
     * @return
     */
    @RequestMapping("message_export")
    public void exportMessage(HttpServletResponse response, String id) {
        equipmentMessageConfService.exportMessage(response, id);
    }

    /**
     * 工程配置 -> 对象管理 -> 设备管理 -> 查看报文数据列表 -> 导入
     * @param file
     * @param equipment_id
     * @return
     */
    @RequestMapping("message_import")
    @ResponseBody
    public Result importMessage(MultipartFile file, String equipment_id) {
        // 1. 保存
        String message = equipmentMessageConfService.importMessage(file, equipment_id);
        Result result = new Result();
        result.setType("alert");
        result.setMessage(message);
        return result;
    }

    /**
     * 工程配置 -> 对象管理 -> 设备管理 -> 唯一编号
     * @param id
     * @param model
     */
    @RequestMapping("equipment_code_edit")
    public void equipmentCodeEdit(String id, Model model){
        EquipmentManage equipmentManage = equipmentManageService.findOne(id);
        model.addAttribute("equipmentManage", equipmentManage);
    }

    /**
     * 工程配置 -> 对象管理 -> 设备管理 -> 唯一编号 -> 保存
     * @param id
     * @param code
     * @return
     */
    @RequestMapping("save_equipment_code")
    @ResponseBody
    public Result saveEquipmentCode(String id, String code){
        String message = equipmentManageService.saveEquipmentCode(id, code);
        Result result = new Result();
        result.setType("alert");
        result.setMessage(message);
        return result;
    }

// ----------------------------------------------------------------------------------------------------------------------------------- 设备管理 End

    /**
     * 工程配置 -> 对象管理 -> 模组温度配置
     * @param model
     */
    @RequestMapping("temperature_list")
    public void temperatureConfigList(Model model) {
        logger.info("工程配置 -> 对象管理 -> 模组温度配置");
    }

    /**
     * 工程配置 -> 对象管理 -> 模组温度配置 -> 数据表
     * @param pageNum
     * @param request
     * @return
     */
    @RequestMapping("temperature_data")
    @ResponseBody
    public PageDto temperatureData(int pageNum, HttpServletRequest request) {
        PageDto pageDto = equipmentTemperatureConfService.findAll(pageNum, request);
        return pageDto;
    }

    /**
     * 工程配置 -> 对象管理 -> 模组温度配置 -> 配置
     * @param model
     * @param id
     */
    @RequestMapping("temperature_edit")
    public void temperatureEdit(Model model, String id) {
        model.addAttribute("group_id", id);
        // 1. 对应的电池单体的list
        List<EquipmentManage> equipmentManageList = equipmentManageService.findByParentId(id);
        // 2. 找到电池包对应的参数
        List<ParameterInfo> parameterInfoList = parameterInfoService.findParameterInfoJustTemperature();
        model.addAttribute("equipmentManageList", equipmentManageList);
        model.addAttribute("parameterInfoList", parameterInfoList);
        if (equipmentManageList.size() > 0){
            // 3. 找到已有的电池单体对应的配置
            List<EquipmentTemperatureConf> equipmentTemperatureConfList = equipmentTemperatureConfService.findByEquipmentList(equipmentManageList);
            model.addAttribute("equipmentTemperatureConfList", equipmentTemperatureConfList);
        }
    }

    /**
     * 工程配置 -> 对象管理 -> 模组温度配置 -> 配置 -> 保存
     * @param data
     * @return
     */
    @RequestMapping("temperature_save")
    @ResponseBody
    public Result temperatureSave(String id, String data){
        String message = equipmentTemperatureConfService.temperatureSave(id, data);
        Result result = new Result();
        if ("保存成功".equals(message)){
            result.setType("success");
            result.setMessage(message);
        } else {
            result.setType("error");
            result.setMessage("保存出错");
        }
        return result;
    }

// ------------------------------------------------------------------------------------------------------------------------- 模组温度配置 End

}
